Idle processor management in virtualized systems via paravirtualization

ABSTRACT

A system and method are disclosed for managing idle processors in virtualized systems. A hypervisor executing on a host comprising one or more physical processors receives an anticipated idle time for a physical processor of the one or more physical processors of the host from a guest operating system of a virtual machine executing on the host. In response to determining that a function of the anticipated idle time exceeds an exit time of a first power state of the physical processor, the physical processor is caused to be halted and placed in the first power state.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation application of co-pending U.S. patentapplication Ser. No. 14/149,061, filed on Jan. 7, 2014, entitled, “IDLEPROCESSOR MANAGEMENT IN VIRTUALIZED SYSTEMS VIA PARAVIRTUALIZATION,”which is herein incorporated by reference.

TECHNICAL FIELD

This disclosure relates to computer systems, and more particularly, tovirtualized computer systems.

BACKGROUND

A virtual machine (VM) is a portion of software that, when executed onappropriate hardware, creates an environment allowing the virtualizationof an actual physical computer system (e.g., a server, a mainframecomputer, etc.). The actual physical computer system is typicallyreferred to as a “host machine” or a “physical machine,” and theoperating system of the host machine is typically referred to as the“host operating system.”

A virtual machine may function as a self-contained platform, executingits own “guest” operating system and software applications. Typically,software on the host machine known as a “hypervisor” (or a “virtualmachine monitor”) manages the execution of one or more virtual machines,providing a variety of functions such as virtualizing and allocatingresources, context switching among virtual machines, etc.

A virtual machine may comprise one or more “virtual processors,” each ofwhich maps, possibly in a many-to-one fashion, to a central processingunit (CPU) of the host machine. Similarly, a virtual machine maycomprise one or more “virtual devices,” each of which maps to a deviceof the host machine (e.g., a network interface device, a CD-ROM drive,etc.). For example, a virtual machine may comprise a virtual disk thatis mapped to an area of storage (known as a “disk image”) of aparticular storage device (e.g., a magnetic hard disk, a UniversalSerial Bus [USB] solid state drive, a Redundant Array of IndependentDisks [RAID] system, a network attached storage [NAS] array, etc.) Thehypervisor manages these mappings in a transparent fashion, therebyenabling the guest operating system and applications executing on thevirtual machine to interact with the virtual processors and virtualdevices as though they were actual physical entities.

BRIEF DESCRIPTION OF THE DRAWINGS

The present disclosure is illustrated by way of example, and not by wayof limitation, and can be more fully understood with reference to thefollowing detailed description when considered in connection with thefigures in which:

FIG. 1 depicts an illustrative computer system architecture, inaccordance with an embodiment of the present disclosure.

FIG. 2 depicts a block diagram of elements of a virtual machine, inaccordance with an embodiment of the present disclosure.

FIG. 3 depicts a flow diagram of one example of a method by which ahypervisor manages processor power states.

FIG. 4 depicts a flow diagram of one example of a method for selecting apower state for a processor based on an anticipated idle time for theprocessor.

FIG. 5 depicts a flow diagram of one example of a method by which aguest operating system provides to a hypervisor an anticipated idle timefor a processor.

FIG. 6 depicts a block diagram of an illustrative computer systemoperating in accordance with embodiments of the disclosure.

DETAILED DESCRIPTION

Described herein is a system and methods for managing idle processors invirtualized systems. In accordance with one embodiment, a hypervisorexecuting on a host computer receives an anticipated idle time for aprocessor of the host computer system from a guest operating system of avirtual machine executing on the host computer system. When theanticipated idle time divided by a performance multiplier exceeds anexit time of a first power state of the processor, the processor iscaused to halt. In one embodiment, the processor also enters the firstpower state.

In accordance with one embodiment, the first power state is selectedfrom a plurality of possible power states of the processor, such thatthe following two conditions are satisfied:

-   -   (i) the exit time of the first power state is less than [the        anticipated processor idle time divided by the performance        multiplier], as noted above; and    -   (ii) if any other power state has an exit time less than [the        anticipated processor idle time divided by the performance        multiplier], then this exit time is less than or equal to the        first power state's exit time.

In other words, the first power state is the power state having thelargest exit time less than [the anticipated processor idle time dividedby the performance multiplier]. As an example, suppose that theanticipated idle time is 21 (units ignored), the performance multiplieris 3, and a processor has four power states with respective exit times{2, 4, 6, 8}. Then the power state with exit time 6 would be selected,as this is the largest exit time that is less than 21/3 =7. Thus, inaccordance with this embodiment, the “deepest” possible power state isselected.

In one embodiment, the performance multiplier is based on an averageload of the processor, or a number of input/output wait tasks of theprocessor, or both. In accordance with some embodiments, the processorcomplies with the Advanced Configuration and Power Interface (ACPI)standard for device configuration and power management. In suchembodiments, the processor can occupy one of four ACPI processor states:C0, C1, C2 and C3.

In accordance with some embodiments of the present disclosure, the guestoperating system is paravirtualized to provide anticipated processoridle times to the hypervisor. Paravirtualization is a technique by whicha guest operating system is modified and recompiled to execute on top ofa hypervisor. More particularly, in some embodiments, one or morecommands may be added to the guest operating system (OS) so that theguest OS, upon determining that the processor will be idle, provides ananticipated idle time to the hypervisor. In some such embodiments,existing code of the guest OS (i.e., code of the guest OS prior toparavirtualization) may include routines for determining that theprocessor will be idle and estimating an anticipated idle time, while insome other embodiments code for one or both of these tasks may be addedto the guest OS in addition to code for providing the anticipated idletime to the hypervisor.

Embodiments of the present disclosure thus use paravirtualization toobtain more accurate estimates of how long a processor will be idle. Incontrast, in virtualized systems of the prior art, the hypervisorguesses the idle times. Moreover, by providing more accurate estimatesof processor idle times, embodiments of the present disclosure canreduce latencies incurred by processor wake-ups, thereby improvingsystem performance while simultaneously reducing power consumption.

FIG. 1 depicts an illustrative architecture of elements of a computersystem 100, in accordance with an embodiment of the present disclosure.It should be noted that other architectures for computer system 100 arepossible, and that the implementation of a computer system utilizingembodiments of the disclosure are not necessarily limited to thespecific architecture depicted by FIG. 1.

As shown in FIG. 1, the computer system 100 is connected to a network150 and comprises central processing unit (CPU) 160, main memory 170,which may include volatile memory devices (e.g., random access memory(RAM)), non-volatile memory devices (e.g., flash memory), and/or othertypes of memory devices, and storage device 180 (e.g., a magnetic harddisk, a Universal Serial Bus [USB] solid state drive, a Redundant Arrayof Independent Disks [RAID] system, a network attached storage [NAS]array, etc.) that serves as a secondary memory, interconnected as shown.The computer system 100 may be a server, a mainframe, a workstation, apersonal computer (PC), a mobile phone, a palm-sized computing device,etc. The network 150 may be a private network (e.g., a local areanetwork (LAN), a wide area network (WAN), intranet, etc.) or a publicnetwork (e.g., the Internet).

It should be noted that although, for simplicity, a single CPU isdepicted in FIG. 1, in some other embodiments computer system 100 maycomprise a plurality of CPUs. Similarly, in some other embodimentscomputer system 100 may comprise a plurality of storage devices 180,rather than a single storage device 180.

Computer system 100 runs a host operating system (OS) 120, whichcomprises software, hardware, or both, that manages the hardwareresources of the computer system and that provides functions such asinterprocess communication, scheduling, virtual memory management, andso forth. In some examples, host operating system 120 also comprises ahypervisor 125, which provides a virtual operating platform for virtualmachine 130 and that manages its execution. In accordance with one suchexample, hypervisor 125 includes an idle processor manager 128 that iscapable of: receiving messages from VM 130 that specify an anticipatedidle time for CPU 160; computing a performance multiplier; determining apower state of CPU 160 that has an exit time less than the quotient ofthe anticipated idle time divided by the performance multiplier; and,when such a power state is determined, of halting CPU 160 and placingCPU 160 in the determined power state; as described in detail below withrespect to FIGS. 3 and 4. It should be noted that in some otherexamples, hypervisor 125 may be external to host OS 120, rather thanembedded within host OS 120.

Virtual machine 130 is a software implementation of a machine thatexecutes programs as though it were an actual physical machine. Itshould be noted that although, for simplicity, a single virtual machineis depicted in FIG. 1, in some other embodiments computer system 100 mayhost a plurality of virtual machines. Virtual machine 130 is describedin more detail below with respect to FIG. 2.

FIG. 2 depicts a block diagram of elements of virtual machine 130, inaccordance with an embodiment of the present disclosure. As shown inFIG. 2, virtual machine 130 comprises a guest operating system 220, avirtual processor 260, a virtual virtual memory 270, and a virtualstorage device 280.

Virtual processor 260 emulates a physical processor and maps to centralprocessing unit (CPU) 160; similarly, virtual storage device 280emulates a physical storage device and maps to storage device 180.Virtual virtual memory 270 maps virtual addresses of virtual machine 130to addresses of the host OS 120's virtual memory, which in turn maps tophysical addresses in main memory 170. In one embodiment, hypervisor 125manages these mappings in a transparent fashion, so that guest OS 220and applications executing on virtual machine 130 interact with virtualprocessor 260, virtual virtual memory 270, and virtual storage device280 as though they were actual physical entities. As noted above, inembodiments where computer system 100 comprises a plurality of CPUs 160,rather than a single CPU, virtual machine 130 may also comprise aplurality of virtual processors 260. Similarly, in embodiments wherecomputer system 100 comprises a plurality of storage devices 180, ratherthan a single storage device, virtual machine 130 may also comprise aplurality of storage devices 180.

Guest operating system (OS) 220 manages virtual machine resources andprovides functions such as interprocess communication, scheduling,memory management, and so forth. In accordance with one embodiment,guest OS 220 is modified via paravirtualization to include an idlenotification engine 225 that is capable of determining that virtualprocessor 260, and by extension CPU 160, will be idle; estimating ananticipated idle time for CPU 160; and providing the anticipated idletime to idle processor manager 128 of hypervisor 125; as described indetail below with respect to FIG. 5.

FIG. 3 depicts a flow diagram of one example of a method 300 by which ahypervisor manages processor power states. The method is performed byprocessing logic that may comprise hardware (circuitry, dedicated logic,etc.), software (such as is run on a general purpose computer system ora dedicated machine), or a combination of both. In one embodiment, themethod is performed by hypervisor 125 of computer system 100, while insome other embodiments, the method may be performed by a hypervisorhosted by some other machine. It should be noted that in some otherembodiments blocks depicted in FIG. 3 may be performed simultaneously orin a different order than that depicted.

At block 301, hypervisor 125 receives an anticipated processor idle timefrom guest OS 220 of virtual machine 130. It should be noted that theanticipated idle time may be provided in a variety of ways, such as viaa message from guest OS 220 to hypervisor 125, or by storing theanticipated idle time in a predefined location of memory 170 that isread by hypervisor 125, etc. In one embodiment, block 301 is performedby idle processor manager 128.

At block 302, hypervisor 125 determines a power state for CPU 160, ifpossible, based on the anticipated idle time received at block 301.Embodiments of operations involved in performing block 302 are describedin detail below with respect to FIG. 4.

Block 303 branches based on whether a power state for CPU 160 wasdetermined at block 302. If so, execution proceeds to block 304,otherwise execution continues back at block 301.

At block 304, hypervisor 125 halts CPU 160 and places CPU 160 in thepower state determined at block 302. In one embodiment, block 304 isperformed by idle processor manager 128. After block 304 is performed,execution continues back at block 301.

FIG. 4 depicts a flow diagram of one example of a method 400 forselecting a power state for a processor based on an anticipated idletime for the processor. The method is performed by processing logic thatmay comprise hardware (circuitry, dedicated logic, etc.), software (suchas is run on a general purpose computer system or a dedicated machine),or a combination of both. In one embodiment, the method is performed byhypervisor 125 of computer system 100 with respect to CPU 160, while insome other embodiments, the method may be performed by a hypervisorhosted by some other machine, or may be performed with respect toanother CPU, or both. It should be noted that in some other embodimentsblocks depicted in FIG. 4 may be performed simultaneously or in adifferent order than that depicted.

At block 401, hypervisor 125 determines the value of a performancemultiplier. In some embodiments, the performance multiplier may be basedon an average load of CPU 160, while in some other embodiments, theperformance multiplier may be based on the number of input/output wait(I/O) tasks of CPU 160, while in yet other embodiments, the performancemultiplier may be based on both the average load and the number of I/Owait tasks. In one embodiment, the performance multiplier is computedaccording to the equation:

m=a+b·λ+c·ω

where λ is the average load of CPU 160, ω is the number of I/O waittasks of CPU 160, and a, b, and c are positive real numbers. It shouldbe noted that in some embodiments the average load may be a simple(i.e., “plain vanilla”) average over a given time interval, while insome other embodiments the average load may be another type of average(e.g., a weighted average, an exponential time-decayed average, etc.).In one embodiment, block 401 is performed by idle processor manager 128.

At block 402, hypervisor 125 determines whether CPU 160 has a powerstate whose exit time is less than the quotient of the anticipated idletime divided by the performance multiplier. In one embodiment, CPU 160complies with the Advanced Configuration and Power Interface (ACPI)standard for device configuration and power management and can occupyone of four ACPI processor states: C0, C1, C2 and C3.

Block 403 branches based on whether CPU 160 does have a power statewhose exit time is less than [anticipated idle time/performancemultiplier]. If so, execution continues at block 404, otherwiseexecution continues at block 405.

At block 404, hypervisor 125 selects a power state of CPU 160. In oneembodiment, hypervisor 125 selects a power state P of CPU 160 such that:

-   -   (i) the exit time of the power state P is less than [the        anticipated processor idle time divided by the performance        multiplier]; and    -   (ii) if any other power state has an exit time less than [the        anticipated processor idle time divided by the performance        multiplier], then this exit time is less than or equal to the        power state P's exit time.

In other words, power state P is the power state of CPU with the largestexit time less than [the anticipated processor idle time divided by theperformance multiplier]. Thus, in this embodiment hypervisor 125 selectsthe “deepest” possible power state at block 404.

It should be noted that when CPU 160 complies with the ACPI standard,hypervisor 125 selects one of the four ACPI processor states C0, C1, C2and C3 at block 404. In one embodiment, block 404 is performed by idleprocessor manager 128. At block 405, a flag is set indicating that nopower state was selected.

FIG. 5 depicts a flow diagram of one example of a method 500 by which aguest operating system provides to a hypervisor an anticipated idle timefor a processor. The method is performed by processing logic that maycomprise hardware (circuitry, dedicated logic, etc.), software (such asis run on a general purpose computer system or a dedicated machine), ora combination of both. In one embodiment, the method is performed byguest OS 220 with respect to CPU 160, while in some other embodiments,the method may be performed by a guest OS hosted by some other virtualmachine and/or physical machine, or may be performed with respect toanother CPU, or both. It should be noted that in some other embodimentsblocks depicted in FIG. 5 may be performed simultaneously or in adifferent order than that depicted.

At block 501, guest OS 220 determines that virtual processor 260, and byextension CPU 160, will be idle. This determination may be in response,for example, to detecting that there are no tasks scheduled forexecution by virtual processor 260, or that there are no interruptscurrently scheduled for, or expected to be scheduled for, virtualprocessor 260 within a given time interval. In one embodiment, block 501is performed by idle notification engine 225 of guest OS 220.

At block 502, guest OS 220 estimates an anticipated processor idle time.In one embodiment, guest OS 220 estimates the idle time based onhistorical idle times (e.g., by computing a simple average of priorprocessor idle times, by computing an exponential time-decayed averageof prior processor idle times, etc.). In one embodiment, block 502 isperformed by idle notification engine 225.

At block 503, guest OS 220 provides the anticipated idle time tohypervisor 125. In one embodiment, the anticipated idle time is providedvia a message from idle notification engine 225 to idle processormanager 128.

FIG. 6 illustrates an illustrative computer system within which a set ofinstructions, for causing the machine to perform any one or more of themethodologies discussed herein, may be executed. In alternativeembodiments, the machine may be connected (e.g., networked) to othermachines in a LAN, an intranet, an extranet, or the Internet. Themachine may operate in the capacity of a server machine in client-servernetwork environment. The machine may be a personal computer (PC), aset-top box (STB), a server, a network router, switch or bridge, or anymachine capable of executing a set of instructions (sequential orotherwise) that specify actions to be taken by that machine. Further,while only a single machine is illustrated, the term “machine” shallalso be taken to include any collection of machines that individually orjointly execute a set (or multiple sets) of instructions to perform anyone or more of the methodologies discussed herein.

The illustrative computer system 600 includes a processing system(processor) 602, a main memory 604 (e.g., read-only memory (ROM), flashmemory, dynamic random access memory (DRAM) such as synchronous DRAM(SDRAM)), a static memory 606 (e.g., flash memory, static random accessmemory (SRAM)), and a data storage device 616, which communicate witheach other via a bus 606.

Processor 602 represents one or more general-purpose processing devicessuch as a microprocessor, central processing unit, or the like. Moreparticularly, the processor 602 may be a complex instruction setcomputing (CISC) microprocessor, reduced instruction set computing(RISC) microprocessor, very long instruction word (VLIW) microprocessor,or a processor implementing other instruction sets or processorsimplementing a combination of instruction sets. The processor 602 mayalso be one or more special-purpose processing devices such as anapplication specific integrated circuit (ASIC), a field programmablegate array (FPGA), a digital signal processor (DSP), network processor,or the like. The processor 602 is configured to execute instructions 626for performing the operations and steps discussed herein.

The computer system 600 may further include a network interface device622. The computer system 600 also may include a video display unit 610(e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)), analphanumeric input device 612 (e.g., a keyboard), a cursor controldevice 614 (e.g., a mouse), and a signal generation device 620 (e.g., aspeaker).

The data storage device 616 may include a computer-readable medium 624on which is stored one or more sets of instructions 626 (e.g.,instructions corresponding to one or more of the methods of FIGS. 3through 5, etc.) embodying any one or more of the methodologies orfunctions described herein. Instructions 626 may also reside, completelyor at least partially, within the main memory 604 and/or within theprocessor 602 during execution thereof by the computer system 600, themain memory 604 and the processor 602 also constitutingcomputer-readable media. Instructions 626 may further be transmitted orreceived over a network via the network interface device 622.

While the computer-readable storage medium 624 is shown in anillustrative embodiment to be a single medium, the term“computer-readable storage medium” should be taken to include a singlemedium or multiple media (e.g., a centralized or distributed database,and/or associated caches and servers) that store the one or more sets ofinstructions. The term “computer-readable storage medium” shall also betaken to include any medium that is capable of storing, encoding orcarrying a set of instructions for execution by the machine and thatcause the machine to perform any one or more of the methodologies of thepresent disclosure. The term “computer-readable storage medium” shallaccordingly be taken to include, but not be limited to, solid-statememories, optical media, and magnetic media.

Although the operations of the methods herein are shown and described ina particular order, the order of the operations of each method may bealtered so that certain operations may be performed in an inverse orderor so that certain operation may be performed, at least in part,concurrently with other operations. In another embodiment, instructionsor sub-operations of distinct operations may be in an intermittentand/or alternating manner.

In the foregoing description, numerous details have been set forth. Itwill be apparent, however, to one skilled in the art, that embodimentsof the present disclosure may be practiced without these specificdetails. In some instances, well-known structures and devices are shownin block diagram form, rather than in detail, in order to avoidobscuring the present disclosure.

Some portions of the detailed descriptions are presented in terms ofalgorithms and symbolic representations of operations on data bitswithin a computer memory. These algorithmic descriptions andrepresentations are the means used by those skilled in the dataprocessing arts to most effectively convey the substance of their workto others skilled in the art. An algorithm is here, and generally,conceived to be a self-consistent sequence of steps leading to a desiredresult. The steps are those requiring physical manipulations of physicalquantities. Usually, though not necessarily, these quantities take theform of electrical or magnetic signals capable of being stored,transferred, combined, compared, and otherwise manipulated. It hasproven convenient at times, principally for reasons of common usage, torefer to these signals as bits, values, elements, symbols, characters,terms, numbers, or the like.

It should be borne in mind, however, that all of these and similar termsare to be associated with the appropriate physical quantities and aremerely convenient labels applied to these quantities. Unlessspecifically stated otherwise, as apparent from the foregoingdiscussion, it is appreciated that throughout the description,discussions utilizing terms such as “receiving,” “executing,” “halting,”“providing,” or the like, refer to the action and processes of acomputer system, or similar electronic computing device, thatmanipulates and transforms data represented as physical (electronic)quantities within the computer system's registers and memories intoother data similarly represented as physical quantities within thecomputer system memories or registers or other such information storage,transmission or display devices.

The algorithms and displays presented herein are not inherently relatedto any particular computer or other apparatus. Various general purposesystems may be used with programs in accordance with the teachingsherein, or it may prove convenient to construct more specializedapparatus to perform the required method steps. In addition, embodimentsof the present disclosure are not described with reference to anyparticular programming language. It will be appreciated that a varietyof programming languages may be used to implement the teachings of thedisclosure as described herein.

Such a computer program may be stored in a computer readable storagemedium, such as, but not limited to, any type of disk including floppydisks, optical disks, CD-ROMs, and magnetic-optical disks, read-onlymemories (ROMs), random access memories (RAMs), EPROMs, EEPROMs,magnetic or optical cards, or any type of media suitable for storingelectronic instructions, each coupled to a computer system bus.Embodiments of the present disclosure may be provided as a computerprogram product, or software, that may include a machine-readable mediumhaving stored thereon instructions, which may be used to program acomputer system (or other electronic devices) to perform a processaccording to the present disclosure. A machine-readable medium includesany mechanism for storing or transmitting information in a form readableby a machine (e.g., a computer). For example, a machine-readable (e.g.,computer-readable) medium includes a machine (e.g., a computer) readablestorage medium (e.g., read only memory (“ROM”), random access memory(“RAM”), magnetic disk storage media, optical storage media, flashmemory devices, etc.), a machine (e.g., computer) readable transmissionmedium (electrical, optical, acoustical or other form of propagatedsignals (e.g., carrier waves, infrared signals, digital signals, etc.)),etc.

It is to be understood that the above description is intended to beillustrative, and not restrictive. Many other embodiments will beapparent to those of skill in the art upon reading and understanding theabove description. The scope of the disclosure should, therefore, bedetermined with reference to the appended claims, along with the fullscope of equivalents to which such claims are entitled.

What is claimed is:
 1. A method comprising: receiving, by a hypervisorof a host comprising one or more physical processors, from a guestoperating system (OS) of a virtual machine, an anticipated idle time fora physical processor of the one or more physical processors; and inresponse to determining, by the hypervisor, that a function of theanticipated idle time, received from the guest OS, exceeds an exit timeof a first power state of a plurality of power states of the physicalprocessor, causing the physical processor to be halted and placed in thefirst power state, wherein the function of the anticipated idle time iscalculated using a performance multiplier.
 2. The method of claim 1wherein the function of the anticipated idle time is calculated bydividing the anticipated idle time by the performance multiplier.
 3. Themethod of claim 1 wherein the function of the anticipated idle timecomprises a quotient of the anticipated idle time divided by theperformance multiplier, wherein the function of the anticipated idletime exceeds the exit time of the first power state by a first positivedelta, and wherein every other power state of the plurality of powerstates satisfies one of the following two conditions: (i) the functionof the anticipated idle time divided by the performance multiplier doesnot exceed an exit time of the other power state; or (ii) the functionof the anticipated idle time exceeds the exit time of the other powerstate by a second positive delta that is larger than the first positivedelta.
 4. The method of claim 1 wherein the first power state is one ofAdvanced Configuration and Power Interface (ACPI) state C0, ACPI stateC1, ACPI state C2, and ACPI state C3.
 5. The method of claim 1 whereinthe performance multiplier is based on an average load of the physicalprocessor.
 6. The method of claim 1 wherein the performance multiplieris based on a number of input/output wait tasks of the physicalprocessor.
 7. The method of claim 1 wherein the performance multiplierequals a sum of: an average load of the physical processor multiplied bya first positive real number; a number of input/output wait tasks of thephysical processor multiplied by a second positive real number; and athird positive real number.
 8. The method of claim 1 wherein the guestOS is to provide the anticipated idle time to the hypervisor bydetermining that a virtual processor associated with the physicalprocessor is to be idle due to a lack of tasks scheduled for executionby the virtual processor or a lack of interrupts scheduled within apredefined item interval.
 9. The method of claim 1 further comprising:in response to determining that the function of the anticipated idletime does not exceed an exit time of any of the plurality of powerstates of the physical processor, refraining from changing a currentpower state of the physical processor and setting a flag indicating thatno power state was selected.
 10. A system comprising: a memory to storea virtual machine that hosts a guest operating system (OS); and one ormore physical processors, operatively coupled to the memory, to: executea hypervisor, receive, by the hypervisor, from the guest OS, ananticipated idle time for a physical processor of the one or morephysical processors; and in response to determining, by the hypervisor,that a function of the anticipated idle time, received from the guestOS, exceeds an exit time of a first power state of a plurality of powerstates of the physical processor, cause the physical processor to behalted and placed in the first power state, wherein the function of theanticipated idle time is calculated using a performance multiplier. 11.The system of claim 10 wherein the function of the anticipated idle timecomprises a quotient of the anticipated idle time divided by theperformance multiplier, wherein the function of the anticipated idletime exceeds the exit time of the first power state by a first positivedelta, and wherein every other power state of the plurality of powerstates satisfies one of the following two conditions: (i) the functionof the anticipated idle time divided by the performance multiplier doesnot exceed an exit time of the other power state; or (ii) the functionof the anticipated idle time exceeds the exit time of the other powerstate by a second positive delta that is larger than the first positivedelta.
 12. The system of claim 10 wherein the first power state is oneof Advanced Configuration and Power Interface (ACPI) state C0, ACPIstate C1, ACPI state C2, and ACPI state C3.
 13. The system of claim 10wherein the performance multiplier is based on an average load of thephysical processor.
 14. The system of claim 10 wherein the performancemultiplier is based on a number of input/output wait tasks of thephysical processor.
 15. The system of claim 10 wherein the performancemultiplier equals a sum of: an average load of the physical processormultiplied by a first positive real number; a number of input/outputwait tasks of the physical processor multiplied by a second positivereal number; and a third positive real number.
 16. The system of claim10 wherein the guest OS is to provide the anticipated idle time to thehypervisor by determining that a virtual processor associated with thephysical processor is to be idle due to a lack of tasks scheduled forexecution by the virtual processor or a lack of interrupts scheduledwithin a predefined item interval.
 17. The system of claim 10 whereinthe hypervisor is further to: in response to determining that thefunction of the anticipated idle time does not exceed an exit time ofany of the plurality of power states of the physical processor, refrainfrom changing a current power state of the physical processor and set aflag indicating that no power state was selected.
 18. A non-transitorycomputer readable storage medium, having instructions stored therein,which when executed, cause one or more physical processors of a host toexecute a hypervisor to perform operations comprising: receiving, by thehypervisor, from a guest operating system (OS) of a virtual machine, ananticipated idle time for a physical processor of the one or morephysical processors; and in response to determining, by the hypervisor,that a function of the anticipated idle time, received from the guestOS, exceeds an exit time of a first power state of a plurality of powerstates of the physical processor, causing the physical processor to behalted and placed in the first power state, wherein the function of theanticipated idle time is calculated using a performance multiplier. 19.The non-transitory computer readable storage medium of claim 17, whereinthe plurality of power states are ACPI state C0, ACPI state C1, ACPIstate C2, and ACPI state C3.
 20. The non-transitory computer readablestorage medium of claim 16, wherein the performance multiplier is basedon at least one of an average load of the physical processor, or anumber of input/output wait tasks of the physical processor.